/**
 * 精简版Prompt规则（从197,453个测试用例中提炼）
 * 
 * 目的：不依赖大型JSON文件，将通用规则和代表性示例直接硬编码
 * 
 * 数据来源：
 * - unittest-prompt-patterns.json (197,453 测试用例)
 * - fuzz-prompt-patterns.json (6,550 fuzz函数)
 * - gn-prompt-patterns.json (5,898 unittest + 6,854 fuzztest目标)
 * - ndk-napi-prompt-patterns.json (79,450 NDK + 83,728 NAPI 调用)
 * - cjson-prompt-patterns.json (503 cJSON文件)
 */

export class CompactPromptRules {
    /**
     * 核心规则：OpenHarmony 单元测试编写规范
     */
    static readonly CORE_RULES = `
## 📋 OpenHarmony 单元测试核心规范

### ⚠️ 最重要的规则（必须遵守！）
**❌ 严禁在测试函数内直接实例化被测对象！**
**✅ 必须使用智能指针 + SetUp/TearDown 模式！**

错误示例（❌ 不要这样写）：
\`\`\`cpp
HWTEST_F(FileAccessServiceTest, Test_001, TestSize.Level1)
{
    FileAccessService service(params);  // ❌ 错误！不要直接实例化
    service.Method();                    // ❌ 错误！不要直接调用
}
\`\`\`

正确示例（✅ 必须这样写）：
\`\`\`cpp
HWTEST_F(FileAccessServiceTest, Test_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);      // ✅ 检查智能指针
    instance_->Method();                 // ✅ 通过instance_调用
}
\`\`\`

### 1. 测试结构（学习自 197,453 个真实测试）
- ✅ 使用 HWTEST_F 框架
- ✅ 测试类继承自 testing::Test
- ✅ **必须**实现 SetUp() 和 TearDown()
- ✅ **必须**在测试类中声明 std::shared_ptr<TargetClass> instance_;
- ✅ **必须**在SetUp中初始化instance_，在TearDown中清理
- ✅ 测试用例命名：ClassName_FunctionName_001, ClassName_FunctionName_002...
- ✅ 测试级别：TestSize.Level0/Level1/Level2（Level1最常见）

### 2. SetUp/TearDown 模式（从 2,005 个实例中总结）
\`\`\`cpp
class MyClassTest : public testing::Test {
public:
    static void SetUpTestCase(void);    // 所有测试前执行一次
    static void TearDownTestCase(void); // 所有测试后执行一次
    void SetUp();                       // 每个测试前执行
    void TearDown();                    // 每个测试后执行
    
    std::shared_ptr<MyClass> instance_; // 使用智能指针管理测试对象
};

void MyClassTest::SetUp()
{
    // ✅ 在 SetUp 中初始化成员变量
    instance_ = std::make_shared<MyClass>(params);
    GTEST_LOG_(INFO) << "SetUp";
}

void MyClassTest::TearDown()
{
    // ✅ 在 TearDown 中清理资源
    instance_ = nullptr;
    GTEST_LOG_(INFO) << "TearDown";
}
\`\`\`

### 3. 不同的函数调用方式（从197,453个测试中总结）

**3.1 智能指针成员方法调用（最常见，必须使用）**
\`\`\`cpp
// ✅ 在测试类中声明
std::shared_ptr<TargetClass> instance_;

// ✅ 在SetUp中初始化
instance_ = std::make_shared<TargetClass>();

// ✅ 在测试中调用
ASSERT_NE(instance_, nullptr);
int result = instance_->MethodName(params);  // 使用 ->
\`\`\`

**3.2 单例模式调用（21,541个示例）**

⚠️ **关键区别：GetInstance() 的返回类型决定调用方式！**

\`\`\`cpp
// 📘 返回引用（返回类型：ClassName&）→ 使用 . 调用
// 实际项目案例：PolicyInfoManager, AccountIAMClient, SandboxMemoryManager
PolicyInfoManager::GetInstance().SetPolicy(tokenId, policy, flag, result);
AccountIAMClient::GetInstance().OpenSession(userId, challenge);
SandboxMemoryManager::GetInstance().SetIsDelayedToUnload(false);
SandboxManagerRdb::GetInstance().db_ = nullptr;  // 访问成员变量也用 .

// 📗 返回指针（返回类型：ClassName*）→ 使用 -> 调用
// 实际项目案例：PageCache, BundleManagerAdapter, PluginManager, SystemAbilityManager
Span* span = PageCache::GetInstance()->NewSpan(1);
BundleManagerAdapter::GetInstance()->GetBundleInfo(name, flag, info, userId);
PluginManager::GetInstance()->AddPlugin(plugin);
auto ability = SystemAbilityManager::GetInstance()->GetSystemAbility(SA_ID);

// 📙 DelayedSingleton 模板（总是返回指针）→ 使用 -> 调用
DelayedSingleton<AbilityManagerAdapter>::GetInstance()->StopUser(id, callback);

// 💡 如何判断？
// 1. 查看头文件：static ClassName& GetInstance() 用 .
// 2. 查看头文件：static ClassName* GetInstance() 用 ->
// 3. 参考同项目中该类的其他测试
// 4. 不确定时优先使用 -> （大多数单例返回指针）

// 🔗 链式调用（每一步根据返回类型选择 . 或 ->）
JSHandle<SourceTextModule> module = 
    thread->GetModuleManager()->GetImportedModule(recordName);
\`\`\`

**3.3 静态方法调用（使用 ::）**
\`\`\`cpp
// 直接通过类名调用静态方法，无需实例
// 实际项目案例：AccessTokenKit, IPCSkeleton, Utils
uint64_t tokenId = IPCSkeleton::GetCallingTokenID();
int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, permission);
std::string result = Utils::ConvertToString(value);
\`\`\`

**3.4 命名空间下的函数调用（使用 ::）**
\`\`\`cpp
// IPC相关
Security::AccessToken::AccessTokenID tokenId = IPCSkeleton::GetCallingTokenID();

// 系统能力
auto systemAbility = SystemAbilityManager::GetInstance()->GetSystemAbility(SERVICE_ID);
\`\`\`

**⚠️ 关键区别**：
| 调用方式 | 使用场景 | 语法 | 示例数量 |
|---------|---------|------|---------|
| \`instance_->Method()\` | 测试类成员（智能指针） | \`->\` | 最常见 |
| \`ClassName::GetInstance().Method()\` | 单例（返回引用） | \`::\` + \`.\` | 21,541+ |
| \`ClassName::GetInstance()->Method()\` | 单例（返回指针） | \`::\` + \`->\` | 常见 |
| \`ClassName::StaticMethod()\` | 静态方法 | \`::\` | 常见 |
| \`obj->GetXxx()->Method()\` | 链式调用 | \`->\` + \`->\` | 常见 |

### 4. HWTEST_F 标准写法（197,453 个测试的统一格式）

**⚠️ 重要：测试函数内只能通过 instance_-> 调用方法，不能直接实例化对象！**

\`\`\`cpp
HWTEST_F(TestClassName, TestCaseName_001, TestSize.Level1)
{
    GTEST_LOG_(INFO) << "TestClassName-begin TestCaseName_001";
    
    // 1. Arrange: 检查instance_（必须！）
    ASSERT_NE(instance_, nullptr) << "TestCaseName_001 instance_ is nullptr";
    
    // 2. Act: 通过instance_->调用方法（必须！）
    int result = instance_->MethodToTest(param1, param2);  // ⚠️ 必须用instance_->
    
    // 3. Assert: 验证结果
    EXPECT_EQ(result, expectedValue);
    EXPECT_TRUE(condition);
    
    GTEST_LOG_(INFO) << "TestClassName-end TestCaseName_001";
}
\`\`\`

**再次强调**：
- ❌ 禁止：\`TargetClass obj(params); obj.Method();\`
- ✅ 必须：\`instance_->Method();\`
- instance_ 必须在测试类的SetUp()中初始化

### 5. Mock 使用模式（657 个 Mock 类的共同特征）

#### 5.1 基础Mock定义
\`\`\`cpp
// Mock类定义
class MockMyClass : public BaseClass {
public:
    MOCK_METHOD0(MethodName, ReturnType());
    MOCK_METHOD1(MethodName, ReturnType(ParamType));
    MOCK_METHOD2(MethodName, ReturnType(ParamType1, ParamType2));
};

// 在测试中使用
HWTEST_F(TestClass, WithMock_001, TestSize.Level1)
{
    auto mockObj = std::make_shared<MockMyClass>();
    
    // 设置期望
    EXPECT_CALL(*mockObj, MethodName())
        .Times(1)
        .WillOnce(testing::Return(expectedValue));
    
    // 执行测试
    auto result = instance_->CallMethodUsingMock(mockObj);
    EXPECT_EQ(result, expectedValue);
}
\`\`\`

#### 5.2 权限验证Mock（OpenHarmony特有，学习自app_file_service/service_other_test.cpp）

**完整的Mock权限验证流程（使用EXPECT_CALL）：**

\`\`\`cpp
// SetUpTestCase中初始化Mock对象
class ServiceTest : public testing::Test {
public:
    static void SetUpTestCase(void);
    static void TearDownTestCase();
    void SetUp() {};
    void TearDown() {};
    
    static inline shared_ptr<IPCSkeletonMock> skeleton = nullptr;
    static inline shared_ptr<AccessTokenKitMock> token = nullptr;
    static inline sptr<Service> service = nullptr;
};

void ServiceTest::SetUpTestCase(void)
{
    service = sptr(new Service(SERVICE_ID));
    skeleton = make_shared<IPCSkeletonMock>();
    IPCSkeletonMock::skeleton = skeleton;
    token = make_shared<AccessTokenKitMock>();
    AccessTokenKitMock::token = token;
}

// 测试权限验证通过的场景
HWTEST_F(ServiceTest, VerifyCaller_0100, TestSize.Level1)
{
    GTEST_LOG_(INFO) << "ServiceTest-begin VerifyCaller_0100";
    
    // 1. Mock IPCSkeleton::GetCallingTokenID()
    EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
    
    // 2. Mock GetTokenType()
    EXPECT_CALL(*token, GetTokenType(_))
        .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
    
    // 3. Mock VerifyAccessToken() - 权限验证通过
    EXPECT_CALL(*token, VerifyAccessToken(_, _))
        .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
    
    // 4. 调用被测方法
    ErrCode ret = service->VerifyCaller();
    EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
    
    GTEST_LOG_(INFO) << "ServiceTest-end VerifyCaller_0100";
}

// 测试权限验证拒绝的场景
HWTEST_F(ServiceTest, VerifyCaller_Denied, TestSize.Level1)
{
    GTEST_LOG_(INFO) << "ServiceTest-begin VerifyCaller_Denied";
    
    EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
    EXPECT_CALL(*token, GetTokenType(_))
        .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE));
    
    // Mock权限验证失败
    EXPECT_CALL(*token, VerifyAccessToken(_, _))
        .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_DENIED));
    
    ErrCode ret = service->VerifyCaller();
    EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
    
    GTEST_LOG_(INFO) << "ServiceTest-end VerifyCaller_Denied";
}

// 测试HAP应用权限验证
HWTEST_F(ServiceTest, VerifyCaller_HAP, TestSize.Level1)
{
    GTEST_LOG_(INFO) << "ServiceTest-begin VerifyCaller_HAP";
    
    EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0));
    
    // HAP类型Token
    EXPECT_CALL(*token, GetTokenType(_))
        .WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP));
    
    EXPECT_CALL(*token, VerifyAccessToken(_, _))
        .WillOnce(Return(Security::AccessToken::PermissionState::PERMISSION_GRANTED));
    
    // 检查是否是系统应用
    EXPECT_CALL(*token, IsSystemAppByFullTokenID(_)).WillOnce(Return(true));
    
    ErrCode ret = service->VerifyCaller();
    EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
    
    GTEST_LOG_(INFO) << "ServiceTest-end VerifyCaller_HAP";
}
\`\`\`

**关键点**：
1. ✅ 使用 EXPECT_CALL(*skeleton, GetCallingTokenID()) Mock获取TokenID
2. ✅ 使用 EXPECT_CALL(*token, GetTokenType(_)) Mock Token类型（NATIVE/HAP）
3. ✅ 使用 EXPECT_CALL(*token, VerifyAccessToken(_, _)) Mock权限验证
4. ✅ 区分TOKEN_NATIVE（系统服务）和TOKEN_HAP（应用）
5. ✅ HAP需要额外检查 IsSystemAppByFullTokenID()
6. ✅ 权限验证结果：PERMISSION_GRANTED 或 PERMISSION_DENIED
\`\`\`

#### 5.3 常见Mock场景
- **权限Mock**: MockTokenId("foundation") - 模拟系统权限
- **IPC Mock**: IPCSkeleton::GetCallingTokenID() - 获取调用者Token
- **AccessToken Mock**: AccessTokenKit::VerifyAccessToken() - 验证权限
- **SetUp中恢复**: 在TearDown中恢复TokenID（如果修改了）

### 6. 断言类型使用（从10种断言的统计）
- EXPECT_EQ / EXPECT_NE：相等/不相等（最常用）
- EXPECT_TRUE / EXPECT_FALSE：布尔判断
- EXPECT_GT / EXPECT_LT / EXPECT_GE / EXPECT_LE：数值比较
- EXPECT_STREQ / EXPECT_STRNE：字符串比较
- ASSERT_NE(ptr, nullptr)：检查指针不为空（必须用ASSERT）
`;

    /**
     * NDK/NAPI 使用规范（从 8,998 个文件中提炼）
     */
    static readonly NDK_NAPI_RULES = `
## 🔧 NDK/NAPI 使用规范

### NDK (Native API) - 5,578 种API的使用模式
- ✅ 函数命名：OH_* 开头
- ✅ 错误处理：检查 OH_*_STATUS 返回值
- ✅ 资源管理：Create/Destroy 成对出现
- ✅ 常用API：OH_LOG_Print, OH_Drawing_*, OH_NativeWindow_*

### NAPI (Node-API) - 296 种API的使用模式
- ✅ 状态检查：napi_status status = napi_ok
- ✅ 错误处理：if (status != napi_ok) return nullptr;
- ✅ 类型转换：napi_get_* 系列函数
- ✅ 对象创建：napi_create_* 系列函数

### 示例：错误处理模式（2,000个实例的共同点）
\`\`\`cpp
// NDK 错误处理
OH_Drawing_Canvas* canvas = OH_Drawing_CanvasCreate();
if (canvas == nullptr) {
    OH_LOG_Print(LOG_ERROR, "Failed to create canvas");
    return ERROR_CODE;
}
// 使用 canvas...
OH_Drawing_CanvasDestroy(canvas);

// NAPI 错误处理
napi_status status;
napi_value result;
status = napi_create_object(env, &result);
if (status != napi_ok) {
    napi_throw_error(env, nullptr, "Failed to create object");
    return nullptr;
}
\`\`\`
`;

    /**
     * cJSON 使用规范（从 503 个文件中总结）
     */
    static readonly CJSON_RULES = `
## 📦 cJSON 使用规范

### API 使用统计（Top 10）
1. cJSON_Parse - 解析JSON字符串
2. cJSON_Delete - 释放JSON对象（必须调用！）
3. cJSON_GetObjectItem - 获取对象属性
4. cJSON_IsObject / cJSON_IsString - 类型检查
5. cJSON_CreateObject - 创建JSON对象

### 错误处理模式（93个实例）
\`\`\`cpp
cJSON* json = cJSON_Parse(jsonString);
if (json == nullptr) {
    // 错误处理
    return ERROR_CODE;
}

cJSON* item = cJSON_GetObjectItem(json, "key");
if (item != nullptr && cJSON_IsString(item)) {
    // 使用item
}

// ⚠️ 必须释放
cJSON_Delete(json);
\`\`\`

### 内存管理模式（1,603个实例）
- ✅ 所有 cJSON_Parse/Create 都必须对应 cJSON_Delete
- ✅ 使用 RAII 封装或智能指针管理生命周期
- ✅ 检查返回值是否为 nullptr
`;

    /**
     * OpenHarmony 特定API规范（从知识库中提炼）
     */
    static readonly OPENHARMONY_API_RULES = `
## 🔐 OpenHarmony 特定API使用规范

### 1. 权限验证相关
\`\`\`cpp
// 1.1 获取TokenID
Security::AccessToken::AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
uint64_t selfTokenId = IPCSkeleton::GetSelfTokenID();

// 1.2 验证权限
int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(
    tokenCaller, 
    "ohos.permission.GET_BUNDLE_INFO"
);

// 1.3 判断结果
if (res == Security::AccessToken::PERMISSION_GRANTED) {
    // 有权限
} else {
    // 无权限
}

// 1.4 测试中Mock权限
HWTEST_F(TestClass, Permission_001, TestSize.Level1)
{
    ASSERT_TRUE(MockTokenId("foundation"));  // Mock系统权限
    
    // 验证权限
    auto tokenId = IPCSkeleton::GetCallingTokenID();
    int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(
        tokenId, 
        "ohos.permission.XXX"
    );
    EXPECT_EQ(res, Security::AccessToken::PERMISSION_GRANTED);
}
\`\`\`

### 2. 常用系统服务相关
\`\`\`cpp
// 2.1 Bundle管理
#include "bundle_mgr_interface.h"
auto bundleMgr = SystemAbilityManager::GetSystemAbilityManager()
    ->GetSystemAbility(BUNDLE_MGR_SERVICE_ID);

// 2.2 Account管理
#include "account_mgr_service.h"
auto accountMgr = AccountMgrService::GetInstance();

// 2.3 设置UID（测试用）
setuid(TEST_UID);     // 设置测试UID
setuid(ROOT_UID);     // 恢复ROOT UID
\`\`\`

### 3. 头文件包含（权限相关）
\`\`\`cpp
#include "accesstoken_kit.h"
#include "ipc_skeleton.h"
#include "token_setproc.h"
#include "nativetoken_kit.h"
\`\`\`

### 4. 测试工具函数
- \`MockTokenId(const std::string& processName)\` - Mock TokenID
- \`SetSelfTokenID(uint64_t tokenId)\` - 设置当前进程Token
- \`setuid(uid_t uid)\` - 设置用户ID（测试用）
`;

    /**
     * GN 配置规范（从 5,898 个 unittest + 6,854 个 fuzztest 目标中总结）
     */
    static readonly GN_RULES = `
## 🔨 BUILD.gn 配置规范

### ohos_unittest 标准格式
\`\`\`gn
import("//build/test.gni")

ohos_unittest("MyClassTest") {
  module_out_path = "subsystem_name/component_name"
  
  sources = [
    "my_class_test.cpp",
  ]
  
  include_dirs = [
    "//path/to/headers",
    "//third_party/googletest/include",
  ]
  
  deps = [
    "//path/to/dependency:target_name",
  ]
  
  external_deps = [
    "c_utils:utils",
    "hilog:libhilog",
  ]
}

group("unittest") {
  testonly = true
  deps = [ ":MyClassTest" ]
}
\`\`\`

### 常用依赖（从 12,446 种 deps 和 863 种 external_deps 中提取）
- c_utils:utils
- hilog:libhilog
- ipc:ipc_core
- samgr:samgr_proxy
`;

    /**
     * Fuzz 测试规范（从 6,550 个 fuzz 函数中总结）
     */
    static readonly FUZZ_RULES = `
## 🎯 Fuzz 测试编写规范（学习自 6,550 个真实 Fuzz 函数）

### ⚠️ Fuzz 测试的核心原则
**Fuzz 测试的目标：发现内存安全漏洞、崩溃、未定义行为**

### 1. LLVMFuzzerTestOneInput 标准结构
\`\`\`cpp
#include "fuzzer_name.h"  // 替换为实际的fuzzer名称
#include <securec.h>
#include <cstddef>
#include <cstdint>
#include <fuzzer/FuzzedDataProvider.h>  // ✅ 推荐使用

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    // ✅ 第一步：空值检查（必须）
    if (data == nullptr || size == 0) {
        return 0;
    }
    
    // ✅ 第二步：使用 FuzzedDataProvider 解析参数（推荐）
    FuzzedDataProvider fdp(data, size);
    
    // ✅ 第三步：根据目标函数参数类型提取数据
    // - std::string: fdp.ConsumeRandomLengthString(max_len)
    // - int32_t: fdp.ConsumeIntegral<int32_t>()
    // - bool: fdp.ConsumeBool()
    // - uint8_t*: fdp.ConsumeBytes<uint8_t>(length)
    // - enum: fdp.ConsumeEnum<EnumType>()
    
    // ✅ 第四步：调用目标函数
    TargetFunction(param1, param2, ...);
    
    return 0;
}
\`\`\`

### 2. 参数大小计算（关键！）
**必须根据目标函数的参数类型计算最小数据大小：**
- 单个 int32_t：\`size < sizeof(int32_t)\` → 至少需要 4 字节
- 两个 int32_t：\`size < 2 * sizeof(int32_t)\` → 至少需要 8 字节
- 字符串参数：\`size < sizeof(size_t) + min_string_length\` → 需要长度字段 + 字符串内容
- 组合类型：累加所有参数的最小大小

**❌ 错误示例：**
\`\`\`cpp
// ❌ 所有函数都用 sizeof(int32_t)，不考虑实际参数
if (size < sizeof(int32_t)) return 0;
\`\`\`

**✅ 正确示例：**
\`\`\`cpp
// ✅ 根据函数签名智能计算
// 函数：void ProcessData(int32_t count, const std::string& data)
if (size < sizeof(int32_t) + sizeof(size_t) + 1) return 0;  // count + string_len + min_char
\`\`\`

### 3. FuzzedDataProvider 使用模式（最佳实践）
\`\`\`cpp
FuzzedDataProvider fdp(data, size);

// ✅ 字符串参数
std::string str = fdp.ConsumeRandomLengthString(size);  // 动态长度
std::string str = fdp.ConsumeBytesAsString(100);        // 固定长度

// ✅ 整数参数
int32_t val = fdp.ConsumeIntegral<int32_t>();
uint64_t val = fdp.ConsumeIntegral<uint64_t>();

// ✅ 布尔参数
bool flag = fdp.ConsumeBool();

// ✅ 字节数组
std::vector<uint8_t> bytes = fdp.ConsumeBytes<uint8_t>(100);

// ✅ 枚举类型
MyEnum e = fdp.ConsumeEnum<MyEnum>();

// ✅ 随机长度（用于数组、容器）
size_t len = fdp.ConsumeIntegralInRange<size_t>(0, max_len);
\`\`\`

### 4. 常见 Fuzz 测试场景

#### 4.1 解析函数（JSON、XML、二进制等）
\`\`\`cpp
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (data == nullptr || size == 0) return 0;
    
    FuzzedDataProvider fdp(data, size);
    std::string jsonStr = fdp.ConsumeRemainingBytesAsString();
    
    // 测试解析函数
    cJSON* json = cJSON_Parse(jsonStr.c_str());
    if (json != nullptr) {
        cJSON_Delete(json);  // ✅ 必须释放
    }
    
    return 0;
}
\`\`\`

#### 4.2 IPC 通信函数（MessageParcel）
\`\`\`cpp
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (data == nullptr || size == 0) return 0;
    
    FuzzedDataProvider fdp(data, size);
    
    // 创建 MessageParcel
    MessageParcel parcel;
    std::vector<uint8_t> bytes = fdp.ConsumeRemainingBytes<uint8_t>();
    parcel.WriteBuffer(bytes.data(), bytes.size());
    
    // 测试反序列化函数
    std::string result;
    parcel.ReadString(result);
    
    return 0;
}
\`\`\`

#### 4.3 字符串处理函数
\`\`\`cpp
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (data == nullptr || size == 0) return 0;
    
    FuzzedDataProvider fdp(data, size);
    std::string str = fdp.ConsumeRemainingBytesAsString();
    
    // 测试字符串处理函数
    ProcessString(str.c_str(), str.length());
    
    return 0;
}
\`\`\`

#### 4.4 内存操作函数
\`\`\`cpp
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (data == nullptr || size == 0) return 0;
    
    FuzzedDataProvider fdp(data, size);
    size_t len = fdp.ConsumeIntegralInRange<size_t>(0, size);
    std::vector<uint8_t> bytes = fdp.ConsumeBytes<uint8_t>(len);
    
    // 测试内存操作函数
    ProcessBuffer(bytes.data(), bytes.size());
    
    return 0;
}
\`\`\`

### 5. ohos_fuzztest BUILD.gn 配置
\`\`\`gn
import("//build/test.gni")

ohos_fuzztest("MyFunctionFuzzTest") {
  module_out_path = "subsystem_name/component_name"
  
  sources = [
    "my_function_fuzz_test.cpp",
  ]
  
  # ⚠️ 必须指定 fuzz_config_file（最重要！）
  fuzz_config_file = "//path/to/fuzztest.config"
  
  include_dirs = [
    "//path/to/headers",
  ]
  
  deps = [
    "//path/to/dependency:target_name",
  ]
  
  external_deps = [
    "fuzztest:fuzztest_main",
    "c_utils:utils",
  ]
}

group("fuzztest") {
  testonly = true
  deps = [ ":MyFunctionFuzzTest" ]
}
\`\`\`

### 6. Fuzz 测试最佳实践
1. ✅ **必须检查空值和大小**：\`if (data == nullptr || size == 0) return 0;\`
2. ✅ **优先使用 FuzzedDataProvider**：简化参数提取，避免手动解析
3. ✅ **正确计算最小数据大小**：根据函数参数类型累加
4. ✅ **不要忽略返回值**：检查函数返回值，但不要因为错误而提前返回
5. ✅ **内存安全**：确保所有分配的内存都被释放
6. ✅ **避免固定值**：使用随机数据，不要使用硬编码的测试值
7. ✅ **覆盖所有参数组合**：确保所有参数路径都被测试
`;

    /**
     * 测试场景覆盖指导（高质量UT必备）
     */
    static readonly TEST_SCENARIOS_RULES = `
## 🎯 测试场景覆盖指导（保证UT高质量）

### 1. 正常流程测试（必须）
**目标：验证函数在正常输入下的正确行为**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_Normal_001, TestSize.Level1)
{
    GTEST_LOG_(INFO) << "MyTest-begin FunctionName_Normal_001";
    
    ASSERT_NE(instance_, nullptr);
    
    // Arrange: 准备正常输入
    std::vector<int> data = {1, 2, 3, 4, 5};
    
    // Act: 调用被测函数
    int result = instance_->ProcessData(data);
    
    // Assert: 验证结果
    EXPECT_EQ(result, 15);
    EXPECT_FALSE(data.empty());
    
    GTEST_LOG_(INFO) << "MyTest-end FunctionName_Normal_001";
}
\`\`\`

### 2. 边界值测试（必须）
**目标：测试边界条件和极端输入**
\`\`\`cpp
// 2.1 空值测试
HWTEST_F(MyTest, FunctionName_NullPointer_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    EXPECT_EQ(instance_->ProcessData(nullptr), -1);  // 错误码
    // 或者: EXPECT_THROW(instance_->ProcessData(nullptr), std::invalid_argument);
}

// 2.2 空容器测试
HWTEST_F(MyTest, FunctionName_EmptyContainer_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    std::vector<int> empty;
    EXPECT_EQ(instance_->ProcessData(empty), 0);
}

// 2.3 最小值/最大值测试
HWTEST_F(MyTest, FunctionName_MinMax_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    EXPECT_EQ(instance_->ProcessData(INT_MIN), expectedMinResult);
    EXPECT_EQ(instance_->ProcessData(INT_MAX), expectedMaxResult);
}

// 2.4 零值测试
HWTEST_F(MyTest, FunctionName_Zero_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    EXPECT_EQ(instance_->ProcessData(0), expectedZeroResult);
}
\`\`\`

### 3. 异常处理测试（必须）
**目标：验证错误处理和异常情况**
\`\`\`cpp
// 3.1 异常抛出测试
HWTEST_F(MyTest, FunctionName_ThrowException_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    EXPECT_THROW(instance_->ProcessData(invalidParam), std::exception);
    EXPECT_THROW(instance_->ProcessData(invalidParam), std::invalid_argument);
    EXPECT_NO_THROW(instance_->ProcessData(validParam));
}

// 3.2 错误返回码测试
HWTEST_F(MyTest, FunctionName_ErrorCode_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    ErrCode result = instance_->ProcessData(invalidParam);
    EXPECT_EQ(result, ERR_INVALID_PARAM);
    EXPECT_NE(result, ERR_OK);
}

// 3.3 资源不足测试
HWTEST_F(MyTest, FunctionName_ResourceExhausted_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    // 模拟内存分配失败或其他资源不足场景
    // 使用 Mock 或特殊配置
}
\`\`\`

### 4. 状态变化测试（必须）
**目标：验证函数对对象状态的影响**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_StateChange_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    
    // 初始状态
    EXPECT_FALSE(instance_->IsInitialized());
    EXPECT_EQ(instance_->GetCount(), 0);
    
    // 执行操作
    instance_->Initialize();
    
    // 验证状态变化
    EXPECT_TRUE(instance_->IsInitialized());
    EXPECT_GT(instance_->GetCount(), 0);
}
\`\`\`

### 5. 并发安全测试（如适用）
**目标：验证多线程环境下的正确性**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_Concurrent_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    
    const int threadCount = 10;
    std::vector<std::thread> threads;
    std::atomic<int> successCount(0);
    
    for (int i = 0; i < threadCount; ++i) {
        threads.emplace_back([&]() {
            if (instance_->ProcessData(data) == ERR_OK) {
                successCount++;
            }
        });
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    EXPECT_EQ(successCount.load(), threadCount);
}
\`\`\`

### 6. 性能测试（如适用）
**目标：验证函数在大量数据下的性能**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_Performance_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    
    const int dataSize = 1000000;
    std::vector<int> largeData(dataSize);
    std::iota(largeData.begin(), largeData.end(), 0);
    
    auto start = std::chrono::high_resolution_clock::now();
    int result = instance_->ProcessData(largeData);
    auto end = std::chrono::high_resolution_clock::now();
    
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    EXPECT_LT(duration.count(), 1000);  // 应在1秒内完成
    EXPECT_EQ(result, expectedValue);
}
\`\`\`

### 7. 往返测试（序列化/反序列化）
**目标：验证序列化和反序列化的一致性**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_RoundTrip_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    
    // 序列化
    std::string json = instance_->Marshal();
    EXPECT_FALSE(json.empty());
    
    // 反序列化
    auto newObj = std::make_shared<MyClass>();
    EXPECT_TRUE(newObj->Unmarshal(json));
    
    // 验证一致性
    EXPECT_EQ(newObj->GetValue(), instance_->GetValue());
}
\`\`\`

### 8. 组合场景测试
**目标：测试多个操作组合的效果**
\`\`\`cpp
HWTEST_F(MyTest, FunctionName_Combined_001, TestSize.Level1)
{
    ASSERT_NE(instance_, nullptr);
    
    // 操作1
    instance_->Initialize();
    EXPECT_TRUE(instance_->IsInitialized());
    
    // 操作2
    instance_->AddData(data1);
    EXPECT_EQ(instance_->GetCount(), 1);
    
    // 操作3
    instance_->AddData(data2);
    EXPECT_EQ(instance_->GetCount(), 2);
    
    // 操作4
    int result = instance_->ProcessAll();
    EXPECT_EQ(result, expectedCombinedResult);
}
\`\`\`

### 9. 测试用例命名规范
- **正常场景**：\`FunctionName_Normal_001\`, \`FunctionName_Success_001\`
- **边界场景**：\`FunctionName_NullPointer_001\`, \`FunctionName_Empty_001\`, \`FunctionName_MaxValue_001\`
- **异常场景**：\`FunctionName_InvalidParam_001\`, \`FunctionName_ThrowException_001\`
- **状态场景**：\`FunctionName_StateChange_001\`, \`FunctionName_Initialized_001\`
- **并发场景**：\`FunctionName_Concurrent_001\`, \`FunctionName_ThreadSafe_001\`
- **性能场景**：\`FunctionName_Performance_001\`, \`FunctionName_LargeData_001\`

### 10. 测试覆盖目标
- ✅ **语句覆盖**：每个语句至少执行一次
- ✅ **分支覆盖**：每个分支（if/else、switch/case）至少测试一次
- ✅ **条件覆盖**：复杂条件的所有组合
- ✅ **路径覆盖**：覆盖主要执行路径
- ✅ **边界覆盖**：测试所有边界值（0、-1、MAX、MIN）
`;

    /**
     * 获取完整的增强规则
     */
    static getFullRules(): string {
        return [
            this.CORE_RULES,
            this.OPENHARMONY_API_RULES,
            this.NDK_NAPI_RULES,
            this.CJSON_RULES,
            this.GN_RULES,
            this.FUZZ_RULES,
            this.TEST_SCENARIOS_RULES
        ].join('\n\n');
    }

    /**
     * 根据源码特征选择相关规则
     */
    static getRelevantRules(sourceCode: string, includeFuzz: boolean = false, includeTestScenarios: boolean = true): string {
        const rules: string[] = [this.CORE_RULES]; // 始终包含核心规则
        
        // 检测是否使用 OpenHarmony 权限相关API
        if (/AccessToken|IPCSkeleton|MockTokenId|VerifyAccessToken/.test(sourceCode)) {
            rules.push(this.OPENHARMONY_API_RULES);
        }
        
        // 检测是否使用 NDK/NAPI
        if (/OH_\w+|napi_\w+/.test(sourceCode)) {
            rules.push(this.NDK_NAPI_RULES);
        }
        
        // 检测是否使用 cJSON
        if (/cJSON_\w+/.test(sourceCode)) {
            rules.push(this.CJSON_RULES);
        }
        
        // 总是包含 GN 规则
        rules.push(this.GN_RULES);
        
        // 如果明确需要 Fuzz 规则，则添加
        if (includeFuzz) {
            rules.push(this.FUZZ_RULES);
        }
        
        // 默认包含测试场景规则（保证UT高质量）
        if (includeTestScenarios) {
            rules.push(this.TEST_SCENARIOS_RULES);
        }
        
        return rules.join('\n\n');
    }
}

